package core.vec;

import core.iterfaces.Matrix;
import core.iterfaces.Vec;
import exception.NotSupportException;

import java.util.HashMap;
import java.util.Map;

/**
 * 稀疏矩阵，使用HashMap<Integer,Double></>存储
 * 其中，key,value表示第i个的元素为value
 */
public class SparseVec  implements Vec {
    /**
     * 保存数据的 map,key,value 表示第i个的元素为value
     */
    private Map<Integer,Double> store;
    /**
     * 长度
     */
    private Integer len;

    /**
     * 构造函数，构造一个长度为0的稀疏向量
     */
    public SparseVec(){
        store = new HashMap<>();
        len = 0;
    }

    /**
     * 构造函数，构造一个长度为len的稀疏向量
     * @param len 稀疏向量的长度
     */
    public SparseVec(int len){
        store = new HashMap<>();
        this.len = len;
    }

    /**
     * 生成一个长度为0的稀疏向量
     * @return
     */
    @Override
    public Vec zero() {
        return new SparseVec();
    }

    /**
     * 生成一个长度为len的稀疏向量
     * @param len 结果向量长度
     * @return 结果向量
     */
    @Override
    public Vec zero(int len) {
        return new SparseVec(len);
    }

    /**
     * 获取第i个元素
     * @param i 表示第i个元素
     * @return 返回的元素值
     */
    @Override
    public double get(int i) {
        if(i<0||i>len){return Double.NaN;}
        if(!store.containsKey(i)){return 0.0;}
        return store.get(i);
    }

    /**
     * 设置向量值
     * @param i   向量索引
     * @param value   值
     */
    @Override
    public void set(int i, double value) {
        if(i<0||i>len){return;}
        store.put(i,value);
    }

    @Override
    public int len() {
        return len;
    }

    /**
     * 外积 c_{ij}=a_{i}*b_{j}
     * @param other 另一个向量
     * @return
     * @throws NotSupportException
     */
    @Override
    public Matrix outProduct(Vec other) throws NotSupportException {
        return null;
    }
}
